/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.brain.prod.manager;

import com.brain.conf.dto.CentroCostosDto;
import com.brain.core.common.UtilCore;
import com.brain.core.configuracion.WebServletContextListener;
import com.brain.core.manager.*;
import com.brain.core.exception.DAOException;
import com.brain.core.hibernate.dao.DAOGenerico;
import com.brain.core.view.mbean.ApplicationMBean;
import com.brain.core.view.mbean.SessionMBean;
import com.brain.prod.dto.OrdenFabDto;
import com.brain.prod.dto.OrdenFabOperacionDto;
import com.brain.prod.dto.OrdenFabProductoDto;
import com.brain.prod.dto.ParteTrabajoCategoriaDto;
import com.brain.prod.dto.ParteTrabajoDto;
import com.brain.prod.dto.ParteTrabajoIndirectoDto;
import com.brain.prod.dto.ParteTrabajoMaquinaDto;
import com.brain.prod.dto.ParteTrabajoOperacionDto;
import com.brain.prod.dto.ParteTrabajoProductoDto;
import com.brain.prod.dto.ParteTrabajoUtillajeDto;
import com.brain.prod.dto.PlanProduccionIndirectoDto;
import com.brain.prod.dto.PlanProduccionMaquinaDto;
import com.brain.prod.dto.PlanProduccionOperarioDto;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author Greip Company
 * @since 09/01/2014
 * @version 1.0
 */
@Service
public class ParteTrabajoOperacionManager extends ComunManager<ParteTrabajoOperacionDto> implements Serializable {
    
    /**
     * Logger permite registrar los errores que ocurren
     * @since 09/01/2014
     */
    private static Logger logger = Logger.getLogger(ParteTrabajoOperacionManager.class);
    
    /**
     * idEntidad utilizado para construir los títulos de los paneles de la entidad
     * @since 09/01/2014
     */
    private Long idEntidad = 318L;
    
    /**
     * applicationMBean permite obtener diferentes valores de la aplicación, como acciones y estilos
     * @since 09/01/2014
     */
    @Autowired
    private ApplicationMBean applicationMBean;
    
    /**
     * springHibernateDao usado para realizar las operaciones de listar, guardar, eliminar
     * @since 09/01/2014
     */
    @Resource
    private DAOGenerico<ParteTrabajoOperacionDto> springHibernateDao;
    
    /**
     * recursosManager permite mostrar mensajes en las vistas
     * @since 09/01/2014
     */
    @Resource
    private RecursosManager recursosManager;
    
    /**
     * Metodo que lista todos los dto (ParteTrabajoOperacionDto)
     * @since 09/01/2014
     * @throws DAOException 
     * @return Lista de dto (ParteTrabajoOperacionDto)
     */
    public List<ParteTrabajoOperacionDto> obtenerTodos() throws DAOException {
        return springHibernateDao.listarTodosDtos(ParteTrabajoOperacionDto.class);
    }
    
    /**
     * Metodo que lista todos los dto (ParteTrabajoOperacionDto) usando filtros
     * @since 09/01/2014
     * @param filtros es el filtro utilizado en la búsqueda
     * @throws DAOException 
     * @return Lista de dto (ParteTrabajoOperacionDto)
     */
    public List<ParteTrabajoOperacionDto> obtenerConFiltro(Map<String, Object> filtros) throws DAOException {
        return springHibernateDao.obtenerDtosConFiltros(ParteTrabajoOperacionDto.class, filtros);
    }
    
    /**
     * Metodo que lista todos los dto (ParteTrabajoOperacionDto) usando filtros y un orden
     * @since 09/01/2014
     * @param filtros es el filtro utilizado en la búsqueda
     * @param orden orden usado en la búsqueda
     * @throws DAOException 
     * @return Lista de dto (ParteTrabajoOperacionDto)
     */
    public List<ParteTrabajoOperacionDto> obtenerConFiltroConOrden(Map<String, Object> filtros, Map<String, String> orden) throws DAOException {
        return springHibernateDao.obtenerDtosConFiltrosConOrden(ParteTrabajoOperacionDto.class, filtros, orden);
    }
    
    /**
     * Metodo que permite obtener la entidad ParteTrabajoOperacionDto usado el id como filtro
     * @since 09/01/2014
     * @param id usado para realizar la búsqueda de la entidad
     * @throws DAOException
     * @return entidad ParteTrabajoOperacionDto
     */
    public ParteTrabajoOperacionDto obtenerPorId(Long id) throws DAOException {
        return springHibernateDao.obtenerDtoPorId(ParteTrabajoOperacionDto.class, id);
    }
    
    /**
     * Metodo que permite inicializar la entidad ParteTrabajoOperacionDto
     * @since 09/01/2014
     * @return entidad ParteTrabajoOperacionDto
     */
    public ParteTrabajoOperacionDto inicializar() {
        ParteTrabajoOperacionDto dto = new ParteTrabajoOperacionDto();
        dto.setParteTrabajoDto(new ParteTrabajoDto());
        dto.setOperacionDto(new OrdenFabOperacionDto());
        dto.setCentroCostoDto(new CentroCostosDto());
        dto.setCantNecesaria(BigDecimal.ZERO);
        dto.setCantRealizada(BigDecimal.ZERO);
        dto.setCantRechazada(BigDecimal.ZERO);
        dto.setProcesado(Boolean.FALSE);
        dto.setTiempoEjecucion(BigDecimal.ZERO);
        dto.setTiempoEstimado(BigDecimal.ZERO);
        dto.setUsoCentro(0);
        return dto;
    }
    
    /**
     * Metodo que permite guardar la entidad ParteTrabajoOperacionDto
     * @since 09/01/2014
     * @param dto entidad a guardar
     * @return retorna una cadena, que indica la página a mostrarse después de guardar la entidad
     */
    public String guardar(ParteTrabajoOperacionDto dto) {
        String ir = "";
        String mensajeTrx = "";
        
        SessionMBean sessionMBean = (SessionMBean) WebServletContextListener.getApplicationContext().getBean("sessionMBean");
        
        if (sessionMBean.getAccion() == applicationMBean.getNuevo()) {
            try {
                UtilCore.General.toUpperCaseDto(dto);
                nuevo(dto);
                mensajeTrx = UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok");
                recursosManager.showMessage(mensajeTrx);
                ir = "";
            } catch (Exception ex) {
                logger.error(ex.getMessage());
                recursosManager.showError(ex.getMessage());
                ir = null;
            }
        } else if (sessionMBean.getAccion() == applicationMBean.getEditar()) {
            try {
                UtilCore.General.toUpperCaseDto(dto);
                editar(dto);
                mensajeTrx = UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok");
                recursosManager.showMessage(mensajeTrx);
                ir = "";
            } catch (Exception ex) {
                logger.error(ex.getMessage());
                recursosManager.showError(ex.getMessage());
                ir = null;
            }
        }
        
        return ir;
    }
    
    public ParteTrabajoOperacionDto generarParteTrabajo(OrdenFabDto ordenFabDto, ParteTrabajoDto parteTrabajoDto) throws DAOException {
        int indice = -1;
        ParteTrabajoOperacionDto h = new ParteTrabajoOperacionDto();
        try {
            if (ordenFabDto != null) {
                if (!ordenFabDto.getListaOperaciones().isEmpty()) {
                    for (OrdenFabOperacionDto c : ordenFabDto.getListaOperaciones()) {
                        h.setCantRealizada(c.getCantidadCompletada());
                        h.setUsoCentro(c.getUsoCentroCosto());
                        h.setProcesado(Boolean.FALSE);
                        h.setOperacionDto(c);
                        System.out.println(parteTrabajoDto);
                        if (parteTrabajoDto != null) {
                            System.out.println("Entro");
                            h.setParteTrabajoDto(parteTrabajoDto);
                        }
                    }
                    nuevo(h);
                }
                if (h != null) {
                    for (int i = 0; i < ordenFabDto.getListaOperaciones().size(); i++) {
                        indice = i;
                    }
                    h.setListaProductos(new ArrayList<ParteTrabajoProductoDto>());
                    h.setListaCategorias(new ArrayList<ParteTrabajoCategoriaDto>());
                    h.setListaIndirectos(new ArrayList<ParteTrabajoIndirectoDto>());
                    h.setListaUtillajes(new ArrayList<ParteTrabajoUtillajeDto>());
                    h.setListaMaquinas(new ArrayList<ParteTrabajoMaquinaDto>());
                    if (indice != -1 && !ordenFabDto.getListaOperaciones().get(indice).getListaProductos().isEmpty()) {
                        ParteTrabajoProductoDto x = new ParteTrabajoProductoDto();
                        for (OrdenFabProductoDto o : ordenFabDto.getListaOperaciones().get(indice).getListaProductos()) {
                            x.setProductoDetaDto(o.getProductoDetaDto());
                            x.setTipoProductoDto(o.getTipoProductoDto());
                            x.setCantPedido(o.getCantidadMovida());
                            x.setUnidadMedidaDto(null);
                        }
                        x.setParteTrabajoOperacionDto(h);
                        h.getListaProductos().add(x);
                    }
                    if (indice != -1 && !ordenFabDto.getPlanProduccionDto().getListaOperacion().get(indice).getListaOperario().isEmpty()) {
                        ParteTrabajoCategoriaDto k = new ParteTrabajoCategoriaDto();
                        for (PlanProduccionOperarioDto c : ordenFabDto.getPlanProduccionDto().getListaOperacion().get(indice).getListaOperario()) {
                            k.setCostoCalculado(c.getCostoCalculado());
                            k.setParteTrabajoOperacionDto(h);
                        }
                        k.setParteTrabajoOperacionDto(h);
                        h.getListaCategorias().add(k);
                    }
                    if (indice != -1 && !ordenFabDto.getPlanProduccionDto().getListaOperacion().get(indice).getListaMaquina().isEmpty()) {
                        ParteTrabajoMaquinaDto m = new ParteTrabajoMaquinaDto();
                        for (PlanProduccionMaquinaDto c : ordenFabDto.getPlanProduccionDto().getListaOperacion().get(indice).getListaMaquina()) {
                            m.setMaquinaDto(c.getMaquinaDto());
                        }
                        m.setParteTrabajoOperacionDto(h);
                        h.getListaMaquinas().add(m);
                    }
                    if (indice != -1 && !ordenFabDto.getPlanProduccionDto().getListaOperacion().get(indice).getListaIndirecto().isEmpty()) {
                        ParteTrabajoIndirectoDto j = new ParteTrabajoIndirectoDto();
                        for (PlanProduccionIndirectoDto c : ordenFabDto.getPlanProduccionDto().getListaOperacion().get(indice).getListaIndirecto()) {
                            j.setCostoIndirectoDto(c.getCostoIndirectoDto());
                        }
                        j.setParteTrabajoOperacionDto(h);
                        h.getListaIndirectos().add(j);
                    }
                }
            }
        } catch (Exception ex) {
            System.out.println("Error en el metodo" + ex.getMessage());
        }
        return h;
    }
    
    /**
     * guardarParteTrabajoOperacion(): permite guardar la entidad ParteTrabajoOperacionDto sin mostrar un mensaje en la vista
     * @since 10/01/2014
     * @param opDto 
     */
    public void guardarParteTrabajoOperacion(ParteTrabajoOperacionDto opDto) {
        try {
            UtilCore.General.toUpperCaseDto(opDto);
            nuevo(opDto);
        } catch (DAOException e) {
            logger.error(e);
        }
    }
    
    /**
     * obtenerUltimoParteTrabajoOperacion(): obtiene el último parte de trabajo registrado en la base de datos
     * @since 10/01/2014
     * @return retorna la entidad ParteTrabajoOperacionDto
     */
    public ParteTrabajoOperacionDto obtenerUltimoParteTrabajoOperacion() {
        ParteTrabajoOperacionDto dto = new ParteTrabajoOperacionDto();
        Long maxId = 0L;        
        try {
            List<ParteTrabajoOperacionDto> l = obtenerTodos();
            for (ParteTrabajoOperacionDto x: l) {
                if (maxId.compareTo(x.getId()) <0) {
                    maxId = x.getId();
                    dto = x;
                }
            }
        } catch (DAOException e) {
            logger.error(e);
        }
        
        return dto;
    }

    public Long getIdEntidad() {
        return idEntidad;
    }
    
    public void setIdEntidad(Long idEntidad) {
        this.idEntidad = idEntidad;
    }
    
    public static Logger getLogger() {
        return logger;
    }
    
    public static void setLogger(Logger logger) {
        ParteTrabajoOperacionManager.logger = logger;
    }
    
    public ApplicationMBean getApplicationMBean() {
        return applicationMBean;
    }
    
    public void setApplicationMBean(ApplicationMBean applicationMBean) {
        this.applicationMBean = applicationMBean;
    }
    
    public DAOGenerico<ParteTrabajoOperacionDto> getSpringHibernateDao() {
        return springHibernateDao;
    }
    
    public void setSpringHibernateDao(DAOGenerico<ParteTrabajoOperacionDto> springHibernateDao) {
        this.springHibernateDao = springHibernateDao;
    }
    
    public RecursosManager getRecursosManager() {
        return recursosManager;
    }
    
    public void setRecursosManager(RecursosManager recursosManager) {
        this.recursosManager = recursosManager;
    }
}
